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..6cc3e2331 --- /dev/null +++ b/applications/zpc/components/zcl_cluster_servers/src/user_credential_cluster_server.cpp @@ -0,0 +1,1208 @@ +/****************************************************************************** + * # 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" +#include "zwave_command_class_user_credential_api.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"}}, + {ATTRIBUTE(USER_CHECKSUM), {"UserChecksum"}}, + {ATTRIBUTE(USER_CHECKSUM_MISMATCH_ERROR), {"UserChecksumError"}}, +}; + +// 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"}}, + {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"}}}; + +/////////////////////////////////////////////////////////////////////////////// +// 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) { + 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( + 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) { + 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( + 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) { + 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, + 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) { + 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( + 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) { + 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, + 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) { + 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( + endpoint_node, + user_uniqueid, + static_cast(credential_type), + 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) { + 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); +} + +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) { + 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( + 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) { + 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( + 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) { + 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( + 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) { + 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( + endpoint_node, + user_unique_id, + 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) { + 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( + 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) { + 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( + 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) { + 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( + 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) { + 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( + endpoint_node, + static_cast(credential_type), + source_user_uniqueid, + source_credential_slot, + destination_user_uniqueid, + 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, + 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) { + 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, + 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) { + 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( + endpoint_node, + 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 +////////////////////////////////////////////////////////////////////////////// +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"); + } +} + +/////////////////////////////////////////////////////////////////////////////// +// 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 +////////////////////////////////////////////////////////////////////////////// + +/** + * @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. + * + * @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. + * + * 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 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", + attribute_store_type_get_node_type_name(updated_node_cpp), + e.what()); + } + + 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. + * + * 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(); + + 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", + 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, + std::function convert_function = nullptr) +{ + 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 that contains the hex representation + auto raw_data = updated_node_cpp.reported>(); + + std::stringstream ss; + ss << std::hex << std::setfill('0'); + for(auto c : raw_data) { + ss << std::setw(2) << static_cast(c); + } + json_payload["value"] = ss.str(); + } 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 + if (convert_function) { + json_payload["value"] = convert_function(json_payload["value"]); + } + + // Create payload + payload_str = json_payload.dump(); + // Handle booleans + if (convert_function) { + boost::replace_all(payload_str, "\"true\"", "true"); + boost::replace_all(payload_str, "\"false\"", "false"); + } + + 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, + 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_credential_data_value(updated_node_cpp, type); + } else { + payload_str = get_payload_value(updated_node_cpp, data.convert_function); + } + 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, + const 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); +} + +/** + * @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 (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); + } + // 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); + } +} + +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. +////////////////////////////////////////////////////////////////////////////// +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); + + // 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 + 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); + // 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); + // 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); + // 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); + // 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); + // 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/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..df2d9df92 --- /dev/null +++ b/applications/zpc/components/zcl_cluster_servers/test/user_credential_cluster_server_test.cpp @@ -0,0 +1,2664 @@ +/****************************************************************************** + * # 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. + * + *****************************************************************************/ + +// Cpp +#include +#include "workaround_for_test.hpp" +#include "attribute.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" +#include "zwave_command_class_version_types.h" + +// ZPC Components +#include "zpc_attribute_store_type_registration.h" + +// Test helpers +#include "zpc_attribute_store_test_helper.h" +#include "sl_log.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 + +// 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, + 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 +static std::vector> mqtt_topics; +static std::vector created_user_id; +static std::vector> + created_credential_ids; +static std::vector created_supported_credential_types; + +// 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; +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; +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; +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. +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; +} +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; +} +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; +} + +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; +} + +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; +} + +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; +} + +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; +} + +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; +} + +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() +{ + 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() +{ + 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) { + 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 + 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(); + 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); + 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); + // 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); + // 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); + // 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); + // 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 + 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(); + + // Setup helper + cpp_endpoint_node = attribute_store::attribute(endpoint_id_node); + + // 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 +///////////////////////////////////////////////////////////////////////// +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) + .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(); +} + +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) +{ + 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); +} +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 + std::vector attribute_names = {"UserType", + "CredentialRule", + "UserActiveState", + "ExpiringTimeoutMinutes", + "UserNameEncoding", + "UserName", + "UserModifierNodeId", + "UserModifierType", + "UserChecksum", + "UserChecksumError"}; + 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", + "AssociationStatus", + "CredentialLearnStatus", + "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; + uint8_t cred_min_length = 0; + uint8_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 + = 0) +{ + 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, + 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_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)); + 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)); + + // 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); + + 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, + std::vector expected_credential_data_vector = {}) +{ + 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 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( + 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_slot_node, + ATTRIBUTE(CREDENTIAL_DATA), + 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)); + + // 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; + 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"); +} + +// 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, + std::vector credential_data_vector = {}) +{ + 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, + REPORTED_ATTRIBUTE, + &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"); + + 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); + } + } 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 + = attribute_store_get_first_child_by_type(credential_slot_node, + ATTRIBUTE(CREDENTIAL_DATA)); + std::vector reported_credential_data + = credential_data_node + .desired>(); + + 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_RFID_CODE; + user_credential_slot_t credential_slot = 1; + const char *credential_data = "abcdef123456"; + + // 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, + {0xab, 0xcd, 0xef, 0x12, 0x34, 0x56}); +} + +/////////////////////////////////////////////////// +// 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 = "cafe12"; + + auto user_id_node = helper_add_complete_credential(user_unique_id, + credential_type, + credential_slot, + 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, + 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, + {0xef, 0x12, 0xca}); +} + +/////////////////////////////////////////////////// +// 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); +} + +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); +} + +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, 2, 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, 2, 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, 2, 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, 2, 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); +} + +/////////////////////////////////////////////////// +// 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), + 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_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"); +} + +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"); +} + +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"); +} + +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"); +} + + +void test_user_credential_cluster_test_all_users_checksum_happy_case() +{ + // 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"); +} + +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 +/////////////////////////////////////////////////// + +void test_user_credential_cluster_test_user_command_support_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_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"; + + // 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, + 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), + "Check value : 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/attribute_store_defined_attribute_types.h b/applications/zpc/components/zpc_attribute_store/include/attribute_store_defined_attribute_types.h index 8d5e36adb..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 @@ -1113,6 +1113,136 @@ 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_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) | 0x0D)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SUPPORTED_SLOT_COUNT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0E)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MIN_LENGTH, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x0F)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MAX_LENGTH, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x10)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_RECOMMENDED_TIMEOUT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x11)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_NUMBER_OF_STEPS, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x12)) + +/// > All Users Checksum +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ALL_USERS_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x13)) + +/// > Users +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_UNIQUE_ID, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x14)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x15)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_MODIFIER_NODE_ID, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x16)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x17)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_ACTIVE_STATE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x18)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x19)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_NAME_ENCODING, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1A)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_RULE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1B)) + +/// > Credentials +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1C)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_DATA, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1D)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_SLOT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1E)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_READ_BACK, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x1F)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x20)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_MODIFIER_NODE_ID, + ((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) | 0x22)) + +// Specific to USER SET +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_OPERATION_TYPE, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x23)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_EXPIRING_TIMEOUT_MINUTES, + ((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) | 0x25)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_TIMEOUT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x26)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STATUS, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x27)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STEPS_REMAINING, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x28)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_LEARN_STOP, + ((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) | 0x2A)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_DESTINATION_CREDENTIAL_SLOT, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2B)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_ASSOCIATION_STATUS, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2C)) + +// Checksums +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2D)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_USER_CHECKSUM_MISMATCH_ERROR, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2E)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM, + ((COMMAND_CLASS_USER_CREDENTIAL << 8) | 0x2F)) +DEFINE_ATTRIBUTE(ATTRIBUTE_COMMAND_CLASS_USER_CREDENTIAL_CREDENTIAL_CHECKSUM_MISMATCH_ERROR, + ((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 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 new file mode 100644 index 000000000..1c96efde4 --- /dev/null +++ b/applications/zpc/components/zpc_attribute_store/include/command_class_types/zwave_command_class_user_credential_types.h @@ -0,0 +1,115 @@ +/****************************************************************************** + * # 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_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 +#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; + +///> 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; + +///> 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; + +///> 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 + +#ifdef __cplusplus +} +#endif + +#endif //ZWAVE_COMMAND_CLASS_USER_CREDENTIALS_TYPES_H +/** @} end zwave_command_class_user_credentials_types */ 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..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 @@ -454,6 +454,74 @@ 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_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}, + {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}, + {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}, + + // 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}, + {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}, + {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, "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}, + {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}, + {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}, + + // 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 99c75db5f..2d4e7fe81 100644 --- a/applications/zpc/components/zwave_command_classes/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/CMakeLists.txt @@ -56,6 +56,8 @@ 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_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 @@ -63,7 +65,13 @@ 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 + 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) target_include_directories( @@ -134,6 +142,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/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..f272038f8 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_checksum_calculator.cpp @@ -0,0 +1,106 @@ +/****************************************************************************** + * # 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. + * + *****************************************************************************/ +// Base class +#include "user_credential_checksum_calculator.h" + +// CRC 16 +#include "zwave_controller_crc16.h" + +// Common definitions +#include "user_credential_definitions.hpp" + +namespace user_credential +{ + +// Used to compute checksums +constexpr uint16_t CRC_INITIALIZATION_VALUE = 0x1D0F; +constexpr uint8_t MAX_CHAR_SIZE = 64; + +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/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..0d8f5e639 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.cpp @@ -0,0 +1,66 @@ +/****************************************************************************** + * # 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" + +// Boost +#include + +// Common definitions +#include "user_credential_definitions.hpp" + +namespace user_credential +{ + +credential_capabilities::credential_capabilities( + const attribute_store::attribute &endpoint_node) +{ + this->is_data_valid = false; + + try { + this->credential_checksum_support + = endpoint_node.child_by_type(ATTRIBUTE(SUPPORT_CREDENTIAL_CHECKSUM)) + .reported(); + this->admin_code_support + = 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)) + .reported(); + + 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_credential_checksum_supported() const +{ + return is_data_valid && credential_checksum_support > 0; +} +bool credential_capabilities::is_admin_code_supported() const +{ + return is_data_valid && admin_code_support > 0; +} +bool credential_capabilities::is_admin_code_deactivation_supported() const +{ + return is_data_valid && admin_code_deactivation_support > 0; +} + +} // 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 new file mode 100644 index 000000000..eb5fb3dc2 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_capabilities.h @@ -0,0 +1,44 @@ +/****************************************************************************** + * # 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 + +// Attribute store +#include "attribute.hpp" + +namespace user_credential +{ + +class credential_capabilities +{ + public: + explicit credential_capabilities( + const attribute_store::attribute &endpoint_node); + ~credential_capabilities() = default; + + 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; + uint8_t admin_code_support = 0; + uint8_t admin_code_deactivation_support = 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_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..a2df80fbb --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_credential_type_capabilities.cpp @@ -0,0 +1,224 @@ +/****************************************************************************** + * # 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 +#include // std::regex_replace + +// 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: + 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); + } + } + + 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_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.cpp b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp new file mode 100644 index 000000000..b110ab718 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.cpp @@ -0,0 +1,294 @@ +/****************************************************************************** + * # 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" + +// Boost +#include "boost/format.hpp" + +// Cpp standard includes +#include +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, + [&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 (!current_credential_slot_node.reported_exists()) { + continue; + } + + if (current_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; +} + +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 new file mode 100644 index 000000000..cf67f66bc --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_helpers.hpp @@ -0,0 +1,281 @@ +/****************************************************************************** + * # 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" + +// Unify Cpp +#include "attribute.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); +/** + * @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); + +/** + * @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); + +/** + * @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); + +/** + * @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); + +/** + * @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); + +/** + * @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); + +/** + * @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); +/** + * @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); + +/** + * @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); +/** + * @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); + +/** + * @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); + +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); + +/** + * @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/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..833327cae --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.cpp @@ -0,0 +1,135 @@ +/****************************************************************************** + * # 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" + +// Common definitions +#include "user_credential_definitions.hpp" + + +namespace 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_users_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()); + attribute_store_log(); + 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)); +} + +bool user_capabilities::is_all_users_checksum_supported() const +{ + 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 new file mode 100644 index 000000000..e450e269e --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/private/user_credential/user_credential_user_capabilities.h @@ -0,0 +1,124 @@ +/****************************************************************************** + * # 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; + + /** + * @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; + + /** + * @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; + // 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_users_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 new file mode 100644 index 000000000..b44bf5466 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.cpp @@ -0,0 +1,2509 @@ + +/****************************************************************************** + * # 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_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" +#include "zwave_controller_crc16.h" + +// Unify +#include "attribute_resolver.h" +#include "attribute_store.h" +#include "attribute_store_helper.h" +#include "attribute_store_type_registration.h" + +// DotDot +#include "unify_dotdot_attribute_store_node_state.h" +#include "dotdot_mqtt_helpers.hpp" + +// Cpp related +#include +#include +#include +#include +#include + +// Cpp Attribute store +#include "attribute.hpp" +#include "zwave_frame_generator.hpp" +#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_credential_type_capabilities.h" +#include "private/user_credential/user_credential_checksum_calculator.h" +#include "private/user_credential/user_credential_helpers.hpp" + +// Using +using namespace user_credential_helpers; + +/** + * @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 + * + */ + +namespace +{ +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; //NOSONAR - false positive since it is warped in a namespace +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 +///////////////////////////////////////////////////////////////////////////// +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); + } +} + +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); + } +} + +///////////////////////////////////////////////////////////////////////////// +// 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 +///////////////////////////////////////////////////////////////////////////// +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::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. + 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( + [[maybe_unused]] attribute_store_node_t node, + uint8_t *frame, + uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "User Capabilities Get"); + + 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( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + 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; + + try { + zwave_frame_parser parser(frame_data, frame_length); + + 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; + } + + 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))); + + parser.read_byte_with_bitmask( + {{USER_CAPABILITIES_REPORT_PROPERTIES1_USER_SCHEDULE_SUPPORT_BIT_MASK, + endpoint_node.emplace_node(ATTRIBUTE(SUPPORT_USER_SCHEDULE))}, + {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))}}); + + parser.read_bitmask( + endpoint_node.emplace_node(ATTRIBUTE(SUPPORTED_USER_TYPES))); + + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while parsing User Capabilities Report frame : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// User Credential Credential Capabilities Get/Report +///////////////////////////////////////////////////////////////////////////// +static sl_status_t + zwave_command_class_user_credential_credential_capabilities_get( + [[maybe_unused]] attribute_store_node_t node, + uint8_t *frame, + uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Capabilities Get"); + + 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) +{ + sl_log_debug(LOG_TAG, "Credential Capabilities Report"); + + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); + + const uint8_t min_expected_size = 5; + + try { + 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"); + return SL_STATUS_FAIL; + } + + 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))}, + {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(); + + // 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); + } + + // 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}); + } + + // 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)); + + parser.read_sequential(2, credential_learn_support_node); + } + + 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); + } + }; + + 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)); + + // 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; + } + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// 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( + [[maybe_unused]] attribute_store_node_t node, + uint8_t *frame, + uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "All Users Checksum Get"); + + 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( + const zwave_controller_connection_info_t *connection_info, + 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 + = zwave_command_class_get_endpoint_node(connection_info); + + try { + zwave_frame_parser parser(frame_data, frame_length); + + 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; + } + + 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", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// Credential Set/Get/Report +///////////////////////////////////////////////////////////////////////////// + +/** + * @brief Trigger a GET credential command + * + * 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 + * + * @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::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 %s, credential slot %d", + user_unique_id_node.reported(), + get_credential_type_debug_str(credential_type).c_str(), + 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( + attribute_store_node_t credential_operation_type_node, + uint8_t *frame, + uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Set"); + try { + 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)) + .desired(); + + sl_log_debug(LOG_TAG, "Operation type : %d", operation_type); + + // Generate the frame + const bool is_delete_operation + = (operation_type == CREDENTIAL_SET_OPERATION_TYPE_DELETE); + + 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)); + + 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()); + } + + // 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; + } + + return SL_STATUS_OK; +} + +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) +{ + sl_log_debug(LOG_TAG, "Credential Get"); + + // 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); + 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, + "Error while generating Credential Get frame : %s", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } + + return SL_STATUS_OK; +} + +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) +{ + if (user_id != 0 && credential_type != 0 && credential_slot != 0) { + sl_log_info(LOG_TAG, + "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 + 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 %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, + [](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 %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) { + credential_type_node.delete_node(); + }, + credential_type); + } else { + sl_log_critical(LOG_TAG, + "Invalid combination of user_id %d, credential_type %s and " + "credential_slot %d for credential deletion", + user_id, + get_credential_type_debug_str(credential_type).c_str(), + credential_slot); + return SL_STATUS_FAIL; + } + + 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"); + + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); + + const uint8_t min_size = 15; + + try { + zwave_frame_parser parser(frame_data, frame_length); + + 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; + } + + 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); + + sl_log_debug(LOG_TAG, + "Credential Report (%d). %s, Slot %d (User %d)", + credential_report_type, + get_credential_type_debug_str(credential_type).c_str(), + credential_slot, + user_id); + + // Helper function to clean up pending credentials slot nodes + auto clean_up_pending_credentials_slot_nodes = [&]() { + 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 %s, user %d)", + credential_slot, + get_credential_type_debug_str(credential_type).c_str(), + user_id); + } 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( + 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 %s, user %d)", + credential_slot, + get_credential_type_debug_str(credential_type).c_str(), + user_id); + + for (auto child: nodes.slot_node.children()) { + child.clear_desired(); + } + } + }; + + // 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); + + attribute_store::attribute credential_type_node; + attribute_store::attribute credential_slot_node; + + switch (credential_report_type) { + case credential_report_type_t::CREDENTIAL_ADDED: + // 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 + 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: + 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: + // First check if this is the first credential interview + credential_type_node + = 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, + "Credential data rejected as it already exists : user %d, " + "credential type %s, credential slot %d", + user_id, + get_credential_type_debug_str(credential_type).c_str(), + 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 %s, credential slot %d", + user_id, + get_credential_type_debug_str(credential_type).c_str(), + credential_slot); + + 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 %s", + user_id, + get_credential_type_debug_str(credential_type).c_str()); + return SL_STATUS_OK; + } + + credential_slot_node = credential_type_node.child_by_type_and_value( + ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + DESIRED_ATTRIBUTE); + + 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 (Already present for user %d, " + "credential type %s, " + "credential slot %d)", + user_id, + 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 + 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, + [&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 + = current_credential_slot_node + .child_by_type(ATTRIBUTE(CREDENTIAL_DATA)) + .get>(DESIRED_OR_REPORTED_ATTRIBUTE); + 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; + } + } + } + }, + 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, + "Credential data rejected as it doesn't respect manufacturer " + "security rules : user %d, credential type %s, " + "credential slot %d", + user_id, + get_credential_type_debug_str(credential_type).c_str(), + 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 %s, credential slot %d", + user_id, + get_credential_type_debug_str(credential_type).c_str(), + 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: + 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", + credential_report_type); + return SL_STATUS_FAIL; + } + + 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 (!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; + } + + // 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))); + + // 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); + } 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) { + sl_log_error(LOG_TAG, + "Error while parsing Credential Report frame : %s", + e.what()); + return SL_STATUS_FAIL; + } + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// Credential Learn Start/Report/Stop +///////////////////////////////////////////////////////////////////////////// +static sl_status_t zwave_command_class_user_credential_credential_learn_start( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Learn Start"); + attribute_store::attribute credential_operation_type_node(node); + + 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); + + 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; + } + + return SL_STATUS_OK; +} + +static sl_status_t zwave_command_class_user_credential_credential_learn_cancel( + attribute_store_node_t node, uint8_t *frame, uint16_t *frame_length) +{ + sl_log_debug(LOG_TAG, "Credential Learn Cancel"); + attribute_store::attribute credential_learn_stop_node(node); + + credential_learn_stop_node.set_reported(1); + credential_learn_stop_node.clear_desired(); + + 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( + const zwave_controller_connection_info_t *connection_info, + const uint8_t *frame_data, + uint16_t frame_length) +{ + attribute_store::attribute endpoint_node + = zwave_command_class_get_endpoint_node(connection_info); + + try { + zwave_frame_parser parser(frame_data, frame_length); + + 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; + } + + // 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: %s / " + "Credential Slot: %d (User %d)", + cred_type_get_enum_value_name(credential_type).c_str(), + credential_slot, + user_id); + + 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 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_or_reported(); + + // Action based of current learn status + std::string learn_status_str; + bool need_deletion = false; + sl_log_level_t log_level = SL_LOG_INFO; + + 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: + 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_ERROR; + 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; + } + + 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 + 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, + "Error while parsing Credential Learn Status Report frame : %s", + e.what()); + + return SL_STATUS_NOT_SUPPORTED; + } + + return SL_STATUS_OK; +} + +///////////////////////////////////////////////////////////////////////////// +// User Unique Identifier Credential Association Set/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) +{ + sl_log_debug(LOG_TAG, + "User Unique Identifier Credential Association Set command"); + attribute_store::attribute destination_credential_slot_node(node); + + try { + frame_generator.initialize_frame( + USER_CREDENTIAL_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); + 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 SL_STATUS_OK; +} + +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) +{ + sl_log_debug(LOG_TAG, "UUIC Association Report"); + + attribute_store::attribute endpoint_node( + zwave_command_class_get_endpoint_node(connection_info)); + + const uint8_t expected_size + = sizeof(ZW_USER_CREDENTIAL_ASSOCIATION_REPORT_FRAME); + + try { + zwave_frame_parser parser(frame_data, frame_length); + + 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; + } + + // 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."); + 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( + endpoint_node, + {source_user_id, REPORTED_ATTRIBUTE}, + {source_credential_type, REPORTED_ATTRIBUTE}, + {source_credential_slot, REPORTED_ATTRIBUTE}); + + // 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(); + } + + // 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)); + return SL_STATUS_OK; + } + + send_message_to_mqtt( + SL_LOG_INFO, + (boost::format("Credential Slot %1% (%2%) (user %3%) moved to " + "Credential slot %4% (user %5%)") + % source_credential_slot + % cred_rule_get_enum_value_name(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 + 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 + = 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) { + 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; + } + } + + // 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, + "Error while parsing UUIC Association Report frame : %s", + e.what()); + return SL_STATUS_FAIL; + } + + 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)) + .get(DESIRED_OR_REPORTED_ATTRIBUTE) + .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); + + // 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); + } + + 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; +} + +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 (!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); + } + + // 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); + + // 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) { + users_interview_state::set_user_0_node(user_unique_id_node); + } + + 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, + uint16_t frame_length) +{ + sl_log_debug(LOG_TAG, "User 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 { + 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; + } + + auto user_report_type = static_cast(parser.read_byte()); + + 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); + + // 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) { //NOSONAR - Don't have a better way to write this + continue; + } + + 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; + } + } + + // 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) { + // 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: + 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) { + 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); + + // 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)) { + 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, + "User %d is the last user to be discovered.", + current_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; + } + + 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 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; + } + + 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); + + 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; + } + + 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; + } + + 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; + + 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); + + 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; + } + + // 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); + + // 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(), + 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", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } + + return result; +} + +///////////////////////////////////////////////////////////////////////////// +// 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"); + + 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; + } + + 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; +} + +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); + + 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; + } + + // 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 %s reported by Credential " + "Checksum Report", + get_credential_type_debug_str(credential_type).c_str()); + return SL_STATUS_FAIL; + } + + 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, + [&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.", + current_credential_slot_node.value_to_string()); + continue; + } + + checksum_calculator.add_node(current_credential_slot_node); + checksum_calculator.add_node( + current_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); + + 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", + e.what()); + return SL_STATUS_NOT_SUPPORTED; + } + + 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.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."); + 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( + [[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); +} + +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 +///////////////////////////////////////////////////////////////////////////// +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_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; + } + + // 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)) { + 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."); + } + } catch (const std::exception &e) { + sl_log_error(LOG_TAG, + "Error while handling network status change : %s", + e.what()); + } +} + +///////////////////////////////////////////////////////////////////////////// +// 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); + 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; + } +} + +// 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); + + 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 + + // 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..72ae89c33 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential.h @@ -0,0 +1,60 @@ +/****************************************************************************** + * # 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" +#include "zwave_command_class_user_credential_types.h" +#include "attribute_store.h" + +#ifdef __cplusplus +#include +#include "sl_log.h" +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 +} // 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 + + + + +#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.cpp b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp new file mode 100644 index 000000000..f1c45093d --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.cpp @@ -0,0 +1,906 @@ +/****************************************************************************** + * # 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 "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 +#include + +using namespace user_credential_helpers; + +/** + * @brief Setup user attributes (desired values) + * + * This function sets the desired values of the user attributes in the attribute store. + * If attributes are not present, they are created. + */ +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) +{ + 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); +} + +sl_status_t zwave_command_class_user_credential_add_new_user( + 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, + 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) +{ + // 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); + + 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; + } + + // 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; + } + + 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; + } + + 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; + } + + // 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; +} + +sl_status_t zwave_command_class_user_credential_delete_user( + attribute_store_node_t endpoint_node, + user_credential_user_unique_id_t user_id) +{ + // 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); + + 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; + } + + 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; +} + +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) +{ + // 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); + + 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; + } + + 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); + + set_user_operation_type(user_id_node, + USER_CREDENTIAL_OPERATION_TYPE_MODIFY); + sl_log_debug(LOG_TAG, "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 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) +{ + // 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); + + 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_type_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; + } + + 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_type_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_type_capabilities + = user_credential::credential_type_capabilities(endpoint_node, + credential_type); + + if (!credential_type_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_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.", + 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_type_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_type_capabilities + = user_credential::credential_type_capabilities(endpoint_node, + credential_type); + + if (!credential_type_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_type_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; +} + +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; +} + +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.is_admin_code_supported()) { + 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.is_admin_code_deactivation_supported()) { + 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; + } + + // 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); + + 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: + return credential_capabilities.is_admin_code_supported(); + default: + sl_log_critical( + LOG_TAG, + "Unknown command %d in zwave_command_class_user_credential_supports", + command_id); + 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.is_admin_code_deactivation_supported(); +} 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..83e662fa2 --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/src/zwave_command_class_user_credential_api.h @@ -0,0 +1,403 @@ +/****************************************************************************** + * # 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); + + +/** + * @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 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 + * + * 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 + +#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/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..e79a13e0d 100644 --- a/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt +++ b/applications/zpc/components/zwave_command_classes/test/CMakeLists.txt @@ -857,7 +857,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 @@ -902,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 new file mode 100644 index 000000000..ed0af695e --- /dev/null +++ b/applications/zpc/components/zwave_command_classes/test/zwave_command_class_user_credential_test.cpp @@ -0,0 +1,4508 @@ +/****************************************************************************** + * # 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" +#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" +#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" + +// 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" + +// 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" +#include "zwave_command_class_notification_mock.h" + +// Used for delayed interview +#include "zwave_network_management_mock.h" + +#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}}, + {ATTRIBUTE(ADMIN_PIN_CODE), {ADMIN_PIN_CODE_GET, ADMIN_PIN_CODE_SET}}}; + +// 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}; + +///////////////////////////////////////////////////// +// HELPERS +///////////////////////////////////////////////////// +struct credential_structure_nodes { + 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()); + }; +}; + +/** + * @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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + nodes.credential_type_node + = nodes.user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + + nodes.credential_slot_node + = nodes.credential_type_node.emplace_node(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot, + value_state); + + return nodes; +} + +//////////////////////////////////////////////////// +// Report helpers +//////////////////////////////////////////////////// + +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_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 + helper_test_report_frame(USER_CAPABILITIES_REPORT, report_frame); +} + +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, + 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_frame report_frame; + + 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) { + report_frame.add(c); + } + for (auto &cl: cl_support) { + report_frame.add(static_cast(cl << 7)); + } + for (auto &c: supported_credential_slots) { + report_frame.add(c); + } + for (auto &c: min_length) { + report_frame.add(c); + } + for (auto &c: max_length) { + report_frame.add(c); + } + for (auto &c: cl_timeout) { + report_frame.add(c); + } + for (auto &c: cl_steps) { + report_frame.add(c); + } + + helper_test_report_frame(CREDENTIAL_CAPABILITIES_REPORT, report_frame); +}; + +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) +{ + zwave_frame report_frame; + report_frame.add(user_id); + report_frame.add(expected_checksum); + + helper_test_report_frame(USER_CHECKSUM_REPORT, report_frame, expected_status); +} + +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_frame report_frame; + report_frame.add(credential_type); + report_frame.add(expected_checksum); + + helper_test_report_frame(CREDENTIAL_CHECKSUM_REPORT, + report_frame, + expected_status); +} + +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_frame report_frame; + + 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); + + helper_test_report_frame(CREDENTIAL_LEARN_REPORT, 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, + user_credential_user_unique_id_t destination_user_id, + user_credential_slot_t destination_credential_slot, + uint8_t credential_association_status, + sl_status_t expected_status = SL_STATUS_OK) +{ + zwave_frame report_frame; + + 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); + + helper_test_report_frame(USER_CREDENTIAL_ASSOCIATION_REPORT, + report_frame, + expected_status); +} + +void helper_test_credential_learn_structure( + 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(user_id_node.is_valid(), + "Credential type node should exist"); + TEST_ASSERT_TRUE_MESSAGE(credential_type_node.is_valid(), + "Credential type node should exist"); + TEST_ASSERT_TRUE_MESSAGE(credential_slot_node.is_valid(), + "Credential type slot should exist"); + + 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); + + user_credential_user_unique_id_t user_id + = user_id_node.reported(); + user_credential_type_t credential_type + = credential_type_node.reported(); + user_credential_slot_t credential_slot + = credential_slot_node.reported(); + + 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); + + helper_test_get_set_frame_happy_case(CREDENTIAL_LEARN_START, + operation_type_node, + learn_start_frame); + + 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::attribute association_user_id_node; + attribute_store::attribute association_credential_slot_node; +}; +association_nodes_t + 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 + = credential_slot_node.emplace_node( + ATTRIBUTE(ASSOCIATION_DESTINATION_USER_ID), + destination_user_id, + DESIRED_ATTRIBUTE); + + association_nodes.association_credential_slot_node + = credential_slot_node.emplace_node( + ATTRIBUTE(ASSOCIATION_DESTINATION_CREDENTIAL_SLOT), + destination_credential_slot, + DESIRED_ATTRIBUTE); + + return association_nodes; +} + +void helper_fill_credential_data( + attribute_store::attribute credential_slot_node, + std::string credential_data, + user_credential_modifier_type_t 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) +{ + 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); +} + +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, + 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, + 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); + 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); +}; + +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 + std::vector user_ids = {12, 15, 18}; + std::map + user_id_nodes = {}; + + for (auto user_id: user_ids) { + user_id_nodes.insert( + {user_id, + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id)}); + } + + // 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}, + {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++) { + helper_simulate_credential_report_frame(0x00, // Credential Add + credential_user_ids[i], + credential_types[i], + credential_slots[i], + 0, + credential_data[i], + 0x02, // Anything but 0 + 0, + 0, + 0); + } +} + +///////////////////////////////////////////////////// +// Test case +///////////////////////////////////////////////////// + +/// 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_setUp(command_class_handler, + &zwave_command_class_user_credential_init, + attributes_binding); +} + +/// Called after each and every test +void tearDown() {} + +//////////////////////////////////////////////////////////////////////////// +// User Capabilities Get/Report +//////////////////////////////////////////////////////////////////////////// +void test_user_credential_user_capabilities_get_happy_case() +{ + helper_test_get_set_frame_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; + + // Test reported values based on the variables in this function + auto test_reported_values = [&]() { + // Create frame object + 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); + + 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 + = cpp_endpoint_id_node.child_by_type(ATTRIBUTE(ALL_USERS_CHECKSUM)); + 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"); + 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_set_frame_happy_case(CREDENTIAL_CAPABILITIES_GET); +} + +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}; + 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 = [&]() { + 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); + + for (uint8_t i = 0; i < credential_type.size(); i++) { + printf("Testing credential batch %d\n", i); + + 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"); + TEST_ASSERT_EQUAL_MESSAGE(credential_type[i], + type_node.reported(), + "Incorrect credential type"); + + 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); + } + }; + + 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, + min_length, + max_length, + cl_timeout, + cl_steps); + + test_report_values(); + + printf("Test with second set of data\n"); + 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, + min_length, + max_length, + cl_timeout, + cl_steps); + + test_report_values(); +} + +//////////////////////////////////////////////////////////////////////////// +// 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"; + + // Create structure + auto user_id_node + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + auto operation_type_node + = 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); + }; + + // 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_MODIFY; + operation_type_node.set_desired(operation_type); + create_and_send_set_frame(); +} + +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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + auto operation_type_node + = 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_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_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_get_set_fail_case(USER_GET, SL_STATUS_NOT_SUPPORTED); +} + +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, + 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, + const std::string &user_name, + sl_status_t expected_status = SL_STATUS_OK) +{ + 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 +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) +{ + 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 ? 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() +{ + 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_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"; + + // 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, + 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 + auto credential_type_node + = 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, + 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 + + printf("First user creation\n"); + + // 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 values + // For the first + first_user_id_node + = 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 + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + 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( + next_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 + 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; + 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"; + + 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 + = 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"); + + // 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(), + "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 + 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 + = 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"); +} + +void test_user_credential_user_report_user_deleted() +{ + // Create user id with reported ID of 0 to simulate user get of id 0 + user_credential_user_unique_id_t user_id = 12; + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + user_id, + DESIRED_ATTRIBUTE); + + auto user_id_count + = cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(); + TEST_ASSERT_EQUAL_MESSAGE(1, user_id_count, "Should have one user by now"); + + // Should delete this user + helper_simulate_user_report_frame(0x04, + user_id, + USER_REPORT_DNE, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + "????"); + + user_id_count + = 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"); +} + +//////////////////////////////////////////////////////////////////////////// +// Credential Set/Get/Report +//////////////////////////////////////////////////////////////////////////// + +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_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(user_id, + credential_type, + credential_slot, + REPORTED_ATTRIBUTE); + auto credential_slot_node = nodes.credential_slot_node; + + // Operation type + auto operation_type_node + = credential_slot_node.emplace_node(ATTRIBUTE(CREDENTIAL_OPERATION_TYPE), + operation_type, + DESIRED_ATTRIBUTE); + // CREDENTIAL_DATA + 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); +} + +//>> Set +void test_user_credential_credential_set_1byte_happy_case() +{ + helper_test_credential_set(USER_CREDENTIAL_OPERATION_TYPE_ADD, + {12}, + 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_get_set_fail_case(CREDENTIAL_SET); +} + +void test_user_credential_credential_set_delete_happy_case() +{ + 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_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(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); + + 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_get_set_fail_case(CREDENTIAL_GET, SL_STATUS_NOT_SUPPORTED); +} + +void test_user_credential_credential_report_no_credential() +{ + user_credential_user_unique_id_t user_id = 12; + 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(0x04, // Credential get, + 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(0x04, + 12, + 1, + 1, + 0, + {}, + 0, + 0, + 0, + 0, + SL_STATUS_FAIL); +} + +void test_user_credential_credential_report_happy_case() +{ + 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_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; + + 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(); + } + + TEST_ASSERT_EQUAL_MESSAGE(expected_credential_slot_count, + count_credential_slot, + "Incorrect credential slot count"); + }; + + auto check_next_credential_node_value + = [&](const attribute_store::attribute &next_credential_type_node, + const attribute_store::attribute &next_credential_slot_node) { + // First check node existence + 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"); + + // 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(); + + zwave_frame get_frame; + get_frame.add(user_id); + get_frame.add(static_cast(0)); + get_frame.add(static_cast(0)); + + // Simulate get on that credential + helper_test_get_set_frame_happy_case(CREDENTIAL_GET, + first_credential_slot_node, + get_frame); + + // Call report + helper_simulate_credential_report_frame(0x04, // Response to get + 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_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 + = first_credential_type_node.child_by_type(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; + + // Simulate get on that credential + 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 + helper_simulate_credential_report_frame(0x04, // Response to get + 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_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 + = user_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_TYPE), 1); + auto third_credential_slot_node + = 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, + 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; + + // Simulate get on that credential + 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 + helper_simulate_credential_report_frame(0x04, // Response to get + 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_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); +} + +//////////////////////////////////////////////////////////////////////////// +// Attribute creation +//////////////////////////////////////////////////////////////////////////// +void test_attribute_creation_happy_case() +{ + helper_set_version(1); + + 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() +{ + helper_set_version(0); + + 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() +{ + 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 + = 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 + = 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; + 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}; + 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; + 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; + network_status_node.set_reported(network_status); + + // Now we check attribute store + 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_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; + network_status_node.set_reported(network_status); + + // Then back in Online Functional + network_status = ZCL_NODE_STATE_NETWORK_STATUS_ONLINE_FUNCTIONAL; + network_status_node.set_reported(network_status); + + // User should still be there + count_user_node(1); + // With right value + helper_test_attribute_value(ATTRIBUTE(USER_UNIQUE_ID), user_id); +} + +void test_user_credential_add_credential_already_defined_cred_type_and_slot() +{ + // Initialize the notification callback + helper_set_version(1); + + 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 + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Capabilities + 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}; + 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}); + + // 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"); + + 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"; + 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; + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), 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_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 + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Se capabilities + 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}; + 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}); + + // 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_add_modify_delete_happy_case() +{ + // 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; + 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, + "zwave_command_class_user_credential_add_new_user " + "should have returned SL_STATUS_OK"); + // Get user node + 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"); + + 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(USER_SET_OPERATION_TYPE_ADD, + 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 = [&]() { + 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(); + + // 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, + "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, + 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; + + helper_simulate_user_report_frame(USER_SET_OPERATION_TYPE_MODIFY, + 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 + 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"); + + 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, + user_type, + user_active_state, + credential_rule, + expiring_timeout, + user_name_encoding, + user_name); +} + +void test_user_credential_credential_add_modify_delete_happy_case() +{ + helper_set_version(1); + + 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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Se capabilities + 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}; + 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}); + + // 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 + = user_id_node.child_by_type(ATTRIBUTE(CREDENTIAL_TYPE)); + + TEST_ASSERT_TRUE_MESSAGE(credential_type_node.is_valid(), + "Credential type node should exist"); + + // Get credential slot + auto credential_slot_node + = credential_type_node.child_by_type(ATTRIBUTE(CREDENTIAL_SLOT)); + + TEST_ASSERT_TRUE_MESSAGE(credential_slot_node.is_valid(), + "Credential slot node should exist"); + + // Create notification report frame + 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 = [&]() { + 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(); + + crb = false; + credential_data = "121212"; + credential_modifier_type = 3; + credential_modifier_node_id = 15; + + // Modify credential + 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(); + + 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(credential_type_node.is_valid(), + "Credential type node should still exist"); + TEST_ASSERT_TRUE_MESSAGE(user_id_node.is_valid(), + "User ID node should still exist"); +} + +void test_user_credential_user_add_capabilites_failure_cases() +{ + // Initialize the notification callback + helper_set_version(1); + + // 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() +{ + helper_set_version(1); + + 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() +{ + helper_set_version(1); + + 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 + helper_set_version(1); + + // 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 + helper_set_version(1); + + 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; + 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}; + 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}); + + // 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 + helper_set_version(1); + + user_credential_user_unique_id_t user_id = 12; + + // Simulate user + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Se capabilities + 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}; + 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, + 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}, + {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, + "ABCD"), + "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 + helper_set_version(1); + + user_credential_user_unique_id_t user_id = 12; + + // Simulate user + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Se capabilities + 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}; + std::vector supported_credential_slots = {1}; + std::vector supported_cred_min_length = {2}; + std::vector supported_cred_max_length = {17}; + 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}); + 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, + "ABCDEF0123456789"), + "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, + "A"), + "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, + "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) +{ + 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); + 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 invalid_cred_slot_node + = valid_cred_type_node.emplace_node(ATTRIBUTE(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, + 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(), + "Invalid Credential Slot node should NOT exist"); + 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(valid_user_node.is_valid(), + "Valid Credential type node should exist"); +} + +void test_user_credential_credential_set_error_report_cred_add_happy_case() +{ + helper_test_credential_rejected_case(0x05); +} + +void test_user_credential_credential_set_error_report_cred_modify_happy_case() +{ + // Common case + helper_test_credential_rejected_case(0x06); + + // 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, + 1, + string_to_uint8_vector("1212"), + 0, + 0, + 0, + 0); +} + +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_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); + + std::vector user_ids = {0, 12, 15, 19}; + for (auto user_id: user_ids) { + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_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(), + cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(), + "All users should have NOT have been removed yet"); + + // 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, // User with ID 0 that might contains credentials + cpp_endpoint_id_node.children(ATTRIBUTE(USER_UNIQUE_ID)).size(), + "Only user 0 should be left"); + + helper_test_attribute_value(ATTRIBUTE(USER_UNIQUE_ID), + static_cast(0)); +} + +// TODO : to be refactored +void test_user_credential_remove_all_credentials_happy_case() +{ + helper_set_version(1); + + 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"); + + helper_simulate_credential_report_frame(0x02, 0, 0, 0, 0, {}, 0, 0, 0, 0); + + for (auto &node: expected_nodes) { + 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"); + } +} + +/** + * @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"); + } +} + +void test_user_credential_remove_all_credentials_of_user() +{ + helper_set_version(1); + + 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"); + + helper_simulate_credential_report_frame(0x02, + user_to_delete, + 0, + 0, + 0, + {}, + 0, + 0, + 0, + 0); + + for (auto &node: expected_nodes) { + auto reported_user_id + = node.user_id_node.reported(); + node.print(); + + helper_test_credential_structure_exists(node, + reported_user_id == user_to_delete); + } +} + +struct expected_node_data { + credential_structure_nodes nodes; + bool deletion_condition; +}; +void test_user_credential_remove_all_credentials_of_user_by_type() +{ + helper_set_version(1); + + user_credential_user_unique_id_t user_to_delete = 12; + user_credential_type_t credential_type_to_delete = 1; + + 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"); + + 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 deletion_condition = node_data.deletion_condition; + + nodes.print(); + helper_test_credential_structure_exists(nodes, deletion_condition); + } +} + +void test_user_credential_remove_all_credentials_by_type() +{ + helper_set_version(1); + + user_credential_type_t credential_type_to_delete = 1; + + 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"); + + 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 deletion_condition = node_data.deletion_condition; + + nodes.print(); + helper_test_credential_structure_exists(nodes, deletion_condition); + } +} + +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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Set capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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::attribute credential_type_node; + attribute_store::attribute credential_slot_node; + auto update_credential_nodes = [&]() { + credential_type_node + = user_id_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type); + + credential_slot_node + = credential_type_node.child_by_type_and_value(ATTRIBUTE(CREDENTIAL_SLOT), + credential_slot); + }; + + 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 + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Set capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Set capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Set capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + 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; + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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; + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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; + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), user_id); + + // Set capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_LEARN_STOP), + stop_flag, + DESIRED_ATTRIBUTE); + + helper_test_get_set_frame_happy_case(CREDENTIAL_LEARN_CANCEL, stop_node); + + TEST_ASSERT_EQUAL_MESSAGE(1, + stop_node.reported(), + "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; + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + 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 + 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, + set_frame); + + // Then simulate report + 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(source_nodes.credential_type_node.is_valid(), + "Old credential type node should still exist"); + // 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(), + "Association user id node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + association_nodes.association_credential_slot_node.is_valid(), + "Association credential slot node should have been removed"); + + TEST_ASSERT_EQUAL_MESSAGE( + 0, + source_nodes.credential_type_node.child_count(), + "Source Credential type node should have no children"); + + // Check destination structure + auto destination_credential_type_node + = 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); + + 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() +{ + // Capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + destination_user_id); + // Already present type + destination_user_id_node.emplace_node(ATTRIBUTE(CREDENTIAL_TYPE), + 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 + 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, + set_frame); + + // Then simulate report + 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(source_nodes.credential_type_node.is_valid(), + "Old credential type node should still exist"); + // 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(), + "Association user id node should have been removed"); + TEST_ASSERT_FALSE_MESSAGE( + association_nodes.association_credential_slot_node.is_valid(), + "Association credential slot node should have been removed"); + + TEST_ASSERT_EQUAL_MESSAGE( + 0, + source_nodes.credential_type_node.child_count(), + "Source Credential type node should have no children"); + + // Check destination structure + auto destination_credential_type_node + = 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); + + helper_test_attribute_value(ATTRIBUTE(ASSOCIATION_STATUS), + association_status, + destination_credential_slot_node); +} + +void test_user_credential_uuic_association_different_slot_same_user() +{ + // Capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + 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, + set_frame); + + // Then simulate report + 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( + 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 + = helper_test_attribute_value(ATTRIBUTE(CREDENTIAL_TYPE), + credential_type, + source_nodes.user_id_node); + + 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); + + helper_test_attribute_value(ATTRIBUTE(ASSOCIATION_STATUS), + association_status, + destination_credential_slot_node); +} + +void test_user_credential_uuic_association_error_code() +{ + // Capabilities + 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}; + 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, + support_admin_code, + support_admin_code_deactivation, + 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 + = cpp_endpoint_id_node.emplace_node(ATTRIBUTE(USER_UNIQUE_ID), + 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 + 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, + set_frame); + + // Then simulate report + 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( + attribute_store_node_exists(source_nodes.credential_slot_node), + "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), + "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; + 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); + + helper_test_attribute_value(ATTRIBUTE(ASSOCIATION_STATUS), + association_status, + destination_credential_slot_node); +} + +void test_get_user_checksum_with_credentials_happy_case() +{ + 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 + = 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 + = {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 < credential_types.size(); i++) { + helper_simulate_credential_report_frame( + 0x00, + user_id, + credential_types[i], + credential_slots[i], + 0, + credential_data[i], + 0x02, // Anything but 0 + 0, + (i + 1) == credential_types.size() ? 0 : credential_types[i + 1], + (i + 1) == credential_types.size() ? 0 : credential_slots[i + 1]); + } + + // Get checksum + auto checksum_node = user_id_node.add_node(ATTRIBUTE(USER_CHECKSUM)); + + 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 + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + "Checksum mismatch"); +} + +void test_get_user_checksum_without_credentials_happy_case() +{ + 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 = "Lillie"; + + // Creating 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 = user_id_node.add_node(ATTRIBUTE(USER_CHECKSUM)); + + 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 = 0xF900; + helper_simulate_user_checksum_report(user_id, expected_checksum); + + // Check if checksum is correct + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + "Checksum mismatch"); +} + +void test_get_user_checksum_without_credentials_mismatch_checksum() +{ + 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 = "Lillie"; + + // Creating 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 = user_id_node.add_node(ATTRIBUTE(USER_CHECKSUM)); + + 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); + + // Simulate checksum mismatch + user_credential_checksum_t expected_checksum = 0xF900; + user_credential_checksum_t error_expected_checksum = expected_checksum + 1; + helper_simulate_user_checksum_report(user_id, + error_expected_checksum, + SL_STATUS_FAIL); + + // Check if checksum is correct + 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); + + 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"); +} + +void test_get_credential_checksum_happy_case() +{ + helper_create_credential_checksum_structure(); + + std::vector 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; + 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 + = cpp_endpoint_id_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + current_credential_type); + + TEST_ASSERT_TRUE_MESSAGE(current_credential_type_node.is_valid(), + "Credential type node should exist"); + + // Get checksum + auto checksum_node + = current_credential_type_node.add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)); + + 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 + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + (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 + = cpp_endpoint_id_node.child_by_type_and_value( + ATTRIBUTE(SUPPORTED_CREDENTIAL_TYPE), + current_credential_type); + + TEST_ASSERT_TRUE_MESSAGE(current_credential_type_node.is_valid(), + "Credential type node should exist"); + + // Get checksum + auto checksum_node + = current_credential_type_node.add_node(ATTRIBUTE(CREDENTIAL_CHECKSUM)); + + 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, + error_checksum, + SL_STATUS_FAIL); + + // Check error checksum + TEST_ASSERT_EQUAL_MESSAGE( + error_checksum, + checksum_node.reported(), + "Reported 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 + + user_credential_checksum_t expected_checksum = expected_checksums[i]; + helper_simulate_credential_checksum_report(current_credential_type, + expected_checksum); + + // Check if checksum is correct + TEST_ASSERT_EQUAL_MESSAGE( + expected_checksum, + checksum_node.reported(), + "Checksum mismatch"); + + TEST_ASSERT_FALSE_MESSAGE( + mismatch_checksum_node.is_valid(), + "Mismatch checksum node should have been removed"); + } +} + +//////////////////////////////////////////////////////////////////////////// +// 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); +} + +//////////////////////////////////////////////////////////////////////////// +// 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 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() 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 +